/**
 * 文档管理模块Mock数据
 * 用于前端开发和测试，模拟后端API返回的数据
 */

/**
 * Mock分类数据
 * 模拟文档分类的树形结构数据
 */
/**
 * Mock分类数据（包含文档列表）
 * 注意：这个数据会在后面添加documents数组，通过categoryId关联
 */
let categoriesWithDocs = null;

/**
 * 获取包含文档列表的分类数据
 */
const getCategoriesWithDocs = () => {
  if (!categoriesWithDocs) {
    // 初始化分类基础数据
    categoriesWithDocs = [
      {
        id: 1,
        name: '编程语言',
        slug: 'programming-languages',
        description: '各种编程语言的学习资料和教程',
        icon: 'code',
        parentId: null,
        sortOrder: 1,
        docCount: 156,
        isActive: true,
        createdAt: '2024-01-01T00:00:00',
        updatedAt: '2024-01-20T10:30:00',
        documents: [],
        children: [
          {
            id: 2,
            name: 'Java',
            slug: 'java',
            description: 'Java编程相关文档',
            icon: 'java-logo',
            parentId: 1,
            sortOrder: 1,
            docCount: 89,
            isActive: true,
            createdAt: '2024-01-02T00:00:00',
            updatedAt: '2024-01-15T08:00:00',
            documents: [],
            children: []
          },
          {
            id: 3,
            name: 'Python',
            slug: 'python',
            description: 'Python编程相关文档',
            icon: 'python-logo',
            parentId: 1,
            sortOrder: 2,
            docCount: 67,
            isActive: true,
            createdAt: '2024-01-02T00:00:00',
            updatedAt: '2024-01-15T08:00:00',
            documents: [],
            children: []
          }
        ]
      },
      {
        id: 4,
        name: '前端开发',
        slug: 'frontend',
        description: '前端开发相关技术文档',
        icon: 'browser',
        parentId: null,
        sortOrder: 2,
        docCount: 234,
        isActive: true,
        createdAt: '2024-01-01T00:00:00',
        updatedAt: '2024-01-20T10:30:00',
        documents: [],
        children: [
          {
            id: 5,
            name: 'React',
            slug: 'react',
            description: 'React框架相关文档',
            icon: 'react-logo',
            parentId: 4,
            sortOrder: 1,
            docCount: 123,
            isActive: true,
            createdAt: '2024-01-02T00:00:00',
            updatedAt: '2024-01-15T08:00:00',
            documents: [],
            children: []
          }
        ]
      }
    ];
  }
  return categoriesWithDocs;
};

export const mockCategories = getCategoriesWithDocs();

/**
 * Mock文档数据
 * 模拟文档列表数据，用于开发和测试
 */
export const mockDocuments = [
  {
    id: 1,
    title: 'Java入门指南',
    slug: 'java-getting-started',
    summary: '适合初学者的Java入门教程，涵盖基础语法和核心概念',
    content: '# Java入门\n\n## 第一章：环境搭建\n\n本章介绍如何安装和配置Java开发环境...\n\n## 第二章：基础语法\n\n学习Java的基本语法...',
    contentHtml: '<h1>Java入门</h1><h2>第一章：环境搭建</h2><p>本章介绍如何安装和配置Java开发环境...</p>',
    contentType: 'direct',
    categoryId: 2,
    categoryName: 'Java',
    tags: ['java', '入门', '教程'],
    status: 'published',
    isPublic: true,
    version: 3,
    language: 'zh-CN',
    authorId: '550e8400-e29b-41d4-a716-446655440000',
    author: '张三',
    viewCount: 1523,
    likeCount: 89,
    publishedAt: '2024-01-15T10:30:00',
    createdAt: '2024-01-10T08:00:00',
    updatedAt: '2024-01-20T14:20:00'
  },
  {
    id: 2,
    title: 'Java进阶指南',
    slug: 'java-advanced',
    summary: '深入讲解Java高级特性和最佳实践',
    content: '# Java进阶\n\n## 第一章：多线程编程\n\n本章介绍Java的多线程编程...',
    contentHtml: '<h1>Java进阶</h1><h2>第一章：多线程编程</h2><p>本章介绍Java的多线程编程...</p>',
    contentType: 'direct',
    categoryId: 2,
    categoryName: 'Java',
    tags: ['java', '进阶', '多线程'],
    status: 'published',
    isPublic: true,
    version: 5,
    language: 'zh-CN',
    authorId: '550e8400-e29b-41d4-a716-446655440000',
    author: '张三',
    viewCount: 2341,
    likeCount: 156,
    publishedAt: '2024-01-10T09:00:00',
    createdAt: '2024-01-05T08:00:00',
    updatedAt: '2024-01-22T16:45:00'
  },
  {
    id: 3,
    title: 'Python基础教程',
    slug: 'python-basics',
    summary: 'Python编程入门教程，适合零基础学习',
    content: '# Python基础\n\n## 第一章：Python简介\n\nPython是一门优雅的编程语言...',
    contentHtml: '<h1>Python基础</h1><h2>第一章：Python简介</h2><p>Python是一门优雅的编程语言...</p>',
    contentType: 'direct',
    categoryId: 3,
    categoryName: 'Python',
    tags: ['python', '入门', '基础'],
    status: 'published',
    isPublic: true,
    version: 2,
    language: 'zh-CN',
    authorId: '550e8400-e29b-41d4-a716-446655440001',
    author: '李四',
    viewCount: 987,
    likeCount: 45,
    publishedAt: '2024-01-18T14:00:00',
    createdAt: '2024-01-15T10:00:00',
    updatedAt: '2024-01-19T11:20:00'
  },
  {
    id: 4,
    title: 'React Hooks完全指南',
    slug: 'react-hooks-guide',
    summary: '深入理解React Hooks的使用方法和最佳实践',
    content: '# React Hooks\n\n## useState的使用\n\nuseState是最基础的Hook...',
    contentHtml: '<h1>React Hooks</h1><h2>useState的使用</h2><p>useState是最基础的Hook...</p>',
    contentType: 'direct',
    categoryId: 5,
    categoryName: 'React',
    tags: ['react', 'hooks', '前端'],
    status: 'published',
    isPublic: true,
    version: 4,
    language: 'zh-CN',
    authorId: '550e8400-e29b-41d4-a716-446655440000',
    author: '张三',
    viewCount: 3456,
    likeCount: 234,
    publishedAt: '2024-01-12T16:30:00',
    createdAt: '2024-01-08T09:00:00',
    updatedAt: '2024-01-21T10:15:00'
  },
  {
    id: 5,
    title: 'Vue 3组合式API',
    slug: 'vue3-composition-api',
    summary: 'Vue 3组合式API详解',
    content: '# Vue 3组合式API\n\n## setup函数\n\nsetup是组合式API的入口...',
    contentHtml: '<h1>Vue 3组合式API</h1><h2>setup函数</h2><p>setup是组合式API的入口...</p>',
    contentType: 'direct',
    categoryId: 4,
    categoryName: '前端开发',
    tags: ['vue', 'vue3', '组合式API'],
    status: 'draft',
    isPublic: false,
    version: 1,
    language: 'zh-CN',
    authorId: '550e8400-e29b-41d4-a716-446655440001',
    author: '李四',
    viewCount: 234,
    likeCount: 12,
    publishedAt: null,
    createdAt: '2024-01-22T15:00:00',
    updatedAt: '2024-01-22T15:00:00'
  },{
    id: 8,
    title: 'Markdown 高级特性演示',
    slug: 'markdown-advanced-features',
    categoryId: 4,  // 属于"开发指南 > 最佳实践"
    categoryName: '前端开发',
    contentType: 'path',
    contentPath: '/doc/markdown-advanced-features.md',
    summary: '演示 Markdown 渲染器支持的所有高级特性：表格、数学公式、图片、提示框等',
    content: '',
    tags: ['Markdown', '文档', '教程'],
    status: 'published',
    author: '技术文档团队',
    authorId: 1,
    viewCount: 1234,
    likeCount: 89,
    isPublic: true,
    createdAt: '2024-01-25T10:00:00Z',
    updatedAt: '2024-01-25T10:00:00Z',
    publishedAt: '2024-01-25T10:00:00Z'
  },
];

/**
 * 初始化分类中的文档列表
 * 将mockDocuments按categoryId分配到对应的分类中
 */
const initCategoryDocuments = () => {
  const categories = getCategoriesWithDocs();

  // 递归查找并填充文档到对应的分类
  const fillDocuments = (catList) => {
    catList.forEach(cat => {
      // 清空documents数组
      cat.documents = [];

      // 查找属于该分类的文档
      mockDocuments.forEach(doc => {
        if (doc.categoryId === cat.id) {
          // 只添加文档的基本信息，避免循环引用
          cat.documents.push({
            id: doc.id,
            title: doc.title,
            slug: doc.slug,
            summary: doc.summary,
            status: doc.status,
            author: doc.author,
            viewCount: doc.viewCount,
            updatedAt: doc.updatedAt
          });
        }
      });

      // 递归处理子分类
      if (cat.children && cat.children.length > 0) {
        fillDocuments(cat.children);
      }
    });
  };

  fillDocuments(categories);
  return categories;
};

// 立即初始化
initCategoryDocuments();

/**
 * Mock用户认证数据
 */
export const mockAuthData = {
  accessToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.mock.token',
  refreshToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.mock.refresh',
  tokenType: 'Bearer',
  expiresIn: 86400,
  user: {
    id: '550e8400-e29b-41d4-a716-446655440000',
    email: 'admin@example.com',
    username: 'admin',
    fullName: '管理员',
    roleName: 'ADMIN'
  }
};

/**
 * 分类Mock数据服务类
 * 提供分类相关的Mock数据操作
 */
export class CategoryMockService {
  /**
   * 获取所有分类（树形结构）
   * @param {boolean} flat - 是否返回平铺列表
   * @returns {Array} 分类列表
   */
  static getAll(flat = false) {
    if (flat) {
      // 平铺模式：将树形结构展开为一维数组
      return this.flattenCategories(mockCategories);
    }
    // 树形模式：返回原始的树形结构
    return mockCategories;
  }

  /**
   * 根据ID获取分类详情
   * @param {number} id - 分类ID
   * @returns {object|null} 分类对象
   */
  static getById(id) {
    return this.findCategoryById(mockCategories, id);
  }

  /**
   * 创建新分类
   * @param {object} data - 分类数据
   * @returns {object} 新创建的分类
   */
  static create(data) {
    const newCategory = {
      id: Math.max(...this.flattenCategories(mockCategories).map(c => c.id)) + 1,
      ...data,
      docCount: 0,
      isActive: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
      children: []
    };
    return newCategory;
  }

  /**
   * 更新分类
   * @param {number} id - 分类ID
   * @param {object} data - 更新数据
   * @returns {object} 更新后的分类
   */
  static update(id, data) {
    const category = this.getById(id);
    if (!category) throw new Error('分类不存在');
    return {
      ...category,
      ...data,
      updatedAt: new Date().toISOString()
    };
  }

  /**
   * 递归查找分类
   * @private
   */
  static findCategoryById(categories, id) {
    for (const category of categories) {
      if (category.id === id) return category;
      if (category.children) {
        const found = this.findCategoryById(category.children, id);
        if (found) return found;
      }
    }
    return null;
  }

  /**
   * 将树形结构展开为平铺列表
   * @private
   */
  static flattenCategories(categories, result = []) {
    categories.forEach(category => {
      const { children, ...rest } = category;
      result.push(rest);
      if (children && children.length > 0) {
        this.flattenCategories(children, result);
      }
    });
    return result;
  }
}

/**
 * 文档Mock数据服务类
 * 提供文档相关的Mock数据操作
 */
export class DocumentMockService {
  /**
   * 获取文档列表（支持分页和筛选）
   * @param {object} params - 查询参数
   * @param {number} params.page - 页码
   * @param {number} params.pageSize - 每页数量
   * @param {number} params.categoryId - 分类ID筛选
   * @param {string} params.status - 状态筛选
   * @param {string} params.keyword - 搜索关键词
   * @param {string} params.tags - 标签筛选（逗号分隔）
   * @param {string} params.sortBy - 排序字段
   * @param {string} params.sortOrder - 排序方向
   * @returns {object} 分页数据
   */
  static getList(params = {}) {
    const {
      page = 1,
      pageSize = 10,
      categoryId,
      status,
      keyword,
      tags,
      sortBy = 'createdAt',
      sortOrder = 'desc'
    } = params;

    // 筛选数据
    let filtered = [...mockDocuments];

    // 按分类筛选
    if (categoryId) {
      filtered = filtered.filter(doc => doc.categoryId === Number(categoryId));
    }

    // 按状态筛选
    if (status) {
      filtered = filtered.filter(doc => doc.status === status);
    }

    // 按关键词搜索（搜索标题、摘要、内容）
    if (keyword) {
      const lowerKeyword = keyword.toLowerCase();
      filtered = filtered.filter(doc =>
        doc.title.toLowerCase().includes(lowerKeyword) ||
        doc.summary.toLowerCase().includes(lowerKeyword) ||
        doc.content.toLowerCase().includes(lowerKeyword)
      );
    }

    // 按标签筛选
    if (tags) {
      const tagArray = tags.split(',').map(t => t.trim());
      filtered = filtered.filter(doc =>
        doc.tags.some(tag => tagArray.includes(tag))
      );
    }

    // 排序
    filtered.sort((a, b) => {
      let aValue = a[sortBy];
      let bValue = b[sortBy];

      // 处理日期字符串
      if (sortBy.includes('At')) {
        aValue = new Date(aValue || 0).getTime();
        bValue = new Date(bValue || 0).getTime();
      }

      // 处理null值
      if (aValue === null || aValue === undefined) return 1;
      if (bValue === null || bValue === undefined) return -1;

      // 比较并返回结果
      if (sortOrder === 'desc') {
        return bValue > aValue ? 1 : -1;
      } else {
        return aValue > bValue ? 1 : -1;
      }
    });

    // 分页
    const start = (page - 1) * pageSize;
    const end = start + pageSize;
    const paginatedData = filtered.slice(start, end);

    // 返回 PageResponse 格式（与后端 API 完全一致）
    const total = filtered.length;
    const totalPages = Math.ceil(total / pageSize);
    
    return {
      data: paginatedData,  // 文档数组
      page: Number(page),
      pageSize: Number(pageSize),
      total,
      totalPages,
      hasNext: page < totalPages,
      hasPrevious: page > 1
    };
  }

  /**
   * 根据slug获取文档详情
   * @param {string} slug - 文档slug
   * @returns {object} 文档对象（与真实 API Service 返回格式一致）
   */
  static getBySlug(slug) {
    const doc = mockDocuments.find(d => d.slug === slug);
    if (!doc) {
      throw new Error('文档不存在');
    }
    // 返回文档对象（增加浏览量）
    return {
      ...doc,
      viewCount: doc.viewCount + 1
    };
  }

  /**
   * 根据ID获取文档详情
   * @param {number} id - 文档ID
   * @returns {object} 文档对象（与真实 API Service 返回格式一致）
   */
  static getById(id) {
    const doc = mockDocuments.find(d => d.id === Number(id));
    if (!doc) {
      throw new Error('文档不存在');
    }
    // 返回文档对象
    return doc;
  }

  /**
   * 创建新文档
   * @param {object} data - 文档数据
   * @returns {object} 新创建的文档
   */
  static create(data) {
    const newDoc = {
      id: Math.max(...mockDocuments.map(d => d.id)) + 1,
      ...data,
      viewCount: 0,
      likeCount: 0,
      version: 1,
      authorId: '550e8400-e29b-41d4-a716-446655440000',
      author: '当前用户',
      publishedAt: data.status === 'published' ? new Date().toISOString() : null,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    };

    // 如果有分类ID，添加分类名称
    if (newDoc.categoryId) {
      const category = CategoryMockService.getById(newDoc.categoryId);
      newDoc.categoryName = category?.name || '';
    }

    return newDoc;
  }

  /**
   * 更新文档
   * @param {number} id - 文档ID
   * @param {object} data - 更新数据
   * @returns {object} 更新后的文档
   */
  static update(id, data) {
    const doc = this.getById(id);
    if (!doc) throw new Error('文档不存在');

    const updated = {
      ...doc,
      ...data,
      version: doc.version + 1,
      updatedAt: new Date().toISOString()
    };

    // 如果状态改为published且之前没有发布时间，设置发布时间
    if (data.status === 'published' && !doc.publishedAt) {
      updated.publishedAt = new Date().toISOString();
    }

    return updated;
  }

  /**
   * 删除文档
   * @param {number} id - 文档ID
   * @returns {boolean} 是否成功
   */
  static delete(id) {
    const index = mockDocuments.findIndex(d => d.id === Number(id));
    if (index === -1) throw new Error('文档不存在');
    return true;
  }

  /**
   * 增加浏览量
   * @param {number} id - 文档ID
   */
  static incrementView(id) {
    const doc = this.getById(id);
    if (!doc) throw new Error('文档不存在');
    return true;
  }
}

/**
 * 认证Mock数据服务类
 */
export class AuthMockService {
  /**
   * 模拟登录
   * @param {object} credentials - 登录凭证
   * @returns {object} 认证响应
   */
  static login(credentials) {
    const { email, password } = credentials;

    // 模拟简单的验证
    if (email && password) {
      return mockAuthData;
    }

    throw new Error('用户名或密码错误');
  }

  /**
   * 模拟注册
   * @param {object} userData - 用户数据
   * @returns {object} 认证响应
   */
  static register(userData) {
    return {
      ...mockAuthData,
      user: {
        ...mockAuthData.user,
        email: userData.email,
        username: userData.username,
        fullName: userData.fullName || userData.username
      }
    };
  }

  /**
   * 模拟刷新Token
   * @param {string} refreshToken - 刷新令牌
   * @returns {object} 新的认证响应
   */
  static refresh(refreshToken) {
    if (refreshToken) {
      return mockAuthData;
    }
    throw new Error('Refresh Token无效');
  }
}

/**
 * 向后兼容的documentationService导出
 * 用于支持现有的页面代码
 * 
 * 注意：这是为了兼容旧代码，新代码请使用 documentation-service.js 中的服务
 */
export const documentationService = {
  /**
   * 获取文档列表（方法名：list，用于兼容现有页面）
   */
  async list(params = {}) {
    // 模拟异步延迟
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.getList(params);
  },

  /**
   * 获取文档列表（方法名：getList，用于新代码）
   */
  async getList(params = {}) {
    // 模拟异步延迟
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.getList(params);
  },

  /**
   * 根据slug获取文档（方法名：get，用于兼容现有页面）
   */
  async get(slug) {
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.getBySlug(slug);
  },

  /**
   * 根据slug或ID获取文档详情（方法名：detail，用于兼容现有页面）
   */
  async detail(slugOrId) {
    await new Promise(resolve => setTimeout(resolve, 300));
    // 判断是数字ID还是slug
    const isNumericId = !isNaN(slugOrId) && !isNaN(parseInt(slugOrId));

    if (isNumericId) {
      // 如果是数字，直接作为ID查询
      return DocumentMockService.getById(slugOrId);
    } else {
      // 如果不是数字，作为slug查询
      return DocumentMockService.getBySlug(slugOrId);
    }
  },

  /**
   * 根据slug获取文档
   */
  async getBySlug(slug) {
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.getBySlug(slug);
  },

  /**
   * 根据ID获取文档
   */
  async getById(id) {
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.getById(id);
  },

  /**
   * 创建文档
   */
  async create(data) {
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.create(data);
  },

  /**
   * 更新文档
   */
  async update(id, data) {
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.update(id, data);
  },

  /**
   * 删除文档
   */
  async delete(id) {
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.delete(id);
  },

  /**
   * 增加浏览量
   */
  async incrementView(id) {
    await new Promise(resolve => setTimeout(resolve, 300));
    return DocumentMockService.incrementView(id);
  },

  /**
   * 获取分类列表（用于兼容现有页面）
   */
  async getCategories() {
    await new Promise(resolve => setTimeout(resolve, 300));
    return {
      success: true,
      data: mockCategories,
      message: '获取分类列表成功'
    };
  }
};

/**
 * 文档 Mock 服务对象（用于适配器）
 * 提供文档相关的异步 Mock 操作
 */
export const documentMockService = {
  async getList(params) {
    return DocumentMockService.getList(params);
  },
  
  async getBySlug(slug) {
    return DocumentMockService.getBySlug(slug);
  },
  
  async getById(id) {
    return DocumentMockService.getById(id);
  },
  
  async create(data) {
    return DocumentMockService.create(data);
  },
  
  async update(id, data) {
    return DocumentMockService.update(id, data);
  },
  
  async delete(id) {
    return DocumentMockService.delete(id);
  },
  
  async incrementView(id) {
    return DocumentMockService.incrementView(id);
  }
};

/**
 * 分类 Mock 服务对象（用于适配器）
 * 提供分类相关的异步 Mock 操作
 */
export const categoryMockService = {
  async getAll(flat = false) {
    return CategoryMockService.getAll(flat);
  },

  async getById(id) {
    return CategoryMockService.getById(id);
  },

  async create(data) {
    return CategoryMockService.create(data);
  },

  async update(id, data) {
    return CategoryMockService.update(id, data);
  },

  async delete(id) {
    return CategoryMockService.delete(id);
  }
};

/**
 * 认证 Mock 服务对象（用于适配器）
 */
export const authMockService = {
  async login(credentials) {
    return AuthMockService.login(credentials);
  },
  
  async register(userData) {
    return AuthMockService.register(userData);
  },
  
  async refresh(refreshToken) {
    return AuthMockService.refresh(refreshToken);
  }
};
